from typing import Dict, Any, List, Optional
# 尝试绝对导入
import sys
import os
# 将项目根目录添加到Python路径
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from src.agent.base_agent import BaseAgent, AgentResult
from src.agent.llm_client import get_llm_client
from langchain_core.messages import SystemMessage
import time
from datetime import datetime, timedelta
import requests
import json
import re

class SummaryGenerationAgent(BaseAgent):
    """重构的总结生成智能体"""
    
    def __init__(self, config_path: str = None):
        super().__init__()
        llm_client_instance = get_llm_client(config_path)
        self.llm_client = llm_client_instance.get_client()
        self.config = llm_client_instance.get_config()
        self.name = "SummaryGenerationAgent"
        self.version = "2.0.0"
        self.config_path = config_path
        
        # 搜索API配置 - 从配置文件或环境变量获取API密钥
        search_config = self.config.get('bocha_search_api', {})
        self.web_search_api_key = search_config.get('api_key', '')
        self.web_search_api_url = search_config.get('base_url', 'https://api.bocha.ai/v1/search')
        self.search_timeout = search_config.get('timeout', 10)
        self.search_num_results = search_config.get('num_results', 3)
        
        # TianAPI配置
        tianapi_config = self.config.get('tianapi', {})
        self.tianapi_key = tianapi_config.get('api_key', '')
        self.tianapi_base_url = tianapi_config.get('base_url', 'https://apis.tianapi.com')
        # 使用正确的通用新闻API端点
        self.tianapi_news_endpoint = tianapi_config.get('news_endpoint', '/generalnews/index')
        self.tianapi_timeout = tianapi_config.get('timeout', 10)
        self.tianapi_num_results = tianapi_config.get('num_results', 5)
    
    def get_name(self) -> str:
        return self.name
    
    def get_version(self) -> str:
        return self.version
    
    def get_dependencies(self) -> List[str]:
        return ["DataCollectionAgent"]
    
    def execute(self, input_data: Dict[str, Any]) -> AgentResult:
        self.log_execution_start()
        start_time = datetime.now()
        
        try:
            # 从输入中获取分类数据 - 支持多种数据源
            classified_data = (
                input_data.get("classified_data") or
                input_data.get("DataCollectionAgent_result") or
                {}
            )
            
            if not classified_data:
                execution_time = (datetime.now() - start_time).total_seconds()
                self.log_execution_end(False, execution_time)
                return AgentResult(
                    success=False,
                    data={},
                    error="缺少分类数据输入"
                )
            
            # 生成总结
            summarized_data = self._generate_summaries(classified_data)
            
            execution_time = (datetime.now() - start_time).total_seconds()
            self.log_execution_end(True, execution_time)
            
            return AgentResult(
                success=True,
                data=summarized_data,
                metadata={
                    "processed_count": len(summarized_data),
                    "execution_time": execution_time,
                    "timestamp": datetime.now().isoformat()
                }
            )
            
        except Exception as e:
            execution_time = (datetime.now() - start_time).total_seconds()
            self.log_execution_end(False, execution_time)
            return AgentResult(
                success=False,
                data={},
                error=f"总结生成失败: {str(e)}"
            )
    
    def _generate_summaries(self, classified_data: Dict) -> Dict:
        """为分类后的多平台热搜数据生成事件总结"""
        if not classified_data:
            return {}
            
        print("开始为各平台热搜数据生成总结...")
        summarized_data = {}
        
        # 为每个平台的数据生成总结
        for platform_key, platform_data in classified_data.items():
            platform_name = platform_data["platform"]
            data = platform_data["data"]
            
            print(f"\n正在处理{platform_name}热搜数据...")
            
            summarized_items = []
            for i, item in enumerate(data):
                print(f"  处理第 {i+1}/{len(data)} 个事件: {item.get('title', '未知标题')}")
                
                try:
                    summary = self._generate_single_summary(item, platform_name)
                    item_with_summary = {
                        **item,
                        "summary": summary,
                        "summary_length": len(summary)
                    }
                    summarized_items.append(item_with_summary)
                    
                    # 添加延迟避免API限流
                    if i < len(data) - 1:
                        time.sleep(0.5)
                        
                except Exception as e:
                    print(f"  处理事件 '{item.get('title', '未知标题')}' 时出错: {e}")
                    # 即使出错也保留原始数据
                    item_with_summary = {
                        **item,
                        "summary": f"生成总结失败: {str(e)}",
                        "summary_length": 0
                    }
                    summarized_items.append(item_with_summary)
            
            summarized_data[platform_key] = {
                **platform_data,
                "data": summarized_items
            }
                
        return summarized_data

    def _is_valid_time_info(self, date_str: str, timestamp: datetime) -> bool:
        """
        验证时间信息的合理性，避免明显错误的时间
        """
        current_year = datetime.now().year
        current_month = datetime.now().month
        
        # 检查年份是否合理（不应该是未来年份或过旧的年份）
        if timestamp:
            # 检查是否为未来时间
            if timestamp > datetime.now():
                return False
            # 检查是否在合理范围内（最近1年内）
            if (datetime.now() - timestamp).days > 365:
                return False
        
        # 检查日期字符串中的年份信息
        if date_str:
            # 检查是否包含明显不合理的年份
            future_year_match = re.search(r'(\d{4})年', date_str)
            if future_year_match:
                year = int(future_year_match.group(1))
                if year > current_year + 1:  # 允许一年的误差
                    return False
            
            # 检查是否包含明显错误的时间描述
            if any(invalid in date_str for invalid in ["2025年", "2026年", "未来", "几年后"]):
                return False
        
        return True
    
    def search_news_info_tianapi(self, query: str) -> Optional[List[Dict[str, str]]]:
        """使用天聚数行（TianAPI）搜索最新新闻信息"""
        if not self.tianapi_key:
            print("天聚数行（TianAPI）密钥未配置，跳过搜索")
            return None
        
        # 简化搜索查询，移除过于复杂的修饰词，保留核心关键词
        simplified_query = self._simplify_query(query)
        
        try:
            # 构建API请求URL
            url = f"{self.tianapi_base_url}{self.tianapi_news_endpoint}"
            
            # 准备请求参数
            params = {
                "key": self.tianapi_key,
                "word": simplified_query,
                "num": self.tianapi_num_results
            }
            
            print(f"[TianAPI] 搜索关键词: '{query}' -> 简化为: '{simplified_query}'")
            print(f"[TianAPI] 请求URL: {url}")
            print(f"[TianAPI] 请求参数: {params}")
            
            # 发送请求
            response = requests.get(url, params=params, timeout=self.tianapi_timeout)
            
            print(f"[TianAPI] 响应状态码: {response.status_code}")
            
            if response.status_code == 200:
                data = response.json()
                print(f"[TianAPI] 响应数据: {data}")
                
                # 检查API返回状态
                if data.get("code") == 200:
                    results_list = []
                    # 从result中获取newslist (修正解析逻辑)
                    news_items = data.get("result", {}).get("newslist", [])
                    
                    print(f"[TianAPI] 从result中获取newslist，数量: {len(news_items)}")
                    
                    # 如果result中没有newslist，尝试直接从data获取
                    if not news_items:
                        news_items = data.get("newslist", [])
                        print(f"[TianAPI] 尝试从data根级获取newslist，数量: {len(news_items)}")
                    
                    for news_item in news_items:
                        # 提取并格式化时间信息
                        result_date = news_item.get("time", news_item.get("ctime", ""))
                        parsed_timestamp = None
                        
                        try:
                            # TianAPI返回的时间格式通常为 "2023-10-25 14:30:25"
                            parsed_timestamp = datetime.strptime(result_date, "%Y-%m-%d %H:%M:%S")
                        except:
                            parsed_timestamp = datetime.now()
                        
                        # 构建标准格式的结果
                        result_info = {
                            "title": news_item.get("title", ""),
                            "snippet": news_item.get("description", ""),
                            "url": news_item.get("url", ""),
                            "source": news_item.get("source", ""),
                            "date": result_date,
                            "timestamp": parsed_timestamp.isoformat(),
                            "raw_timestamp": parsed_timestamp
                        }
                        
                        # 验证时间信息的合理性
                        if self._is_valid_time_info(result_date, parsed_timestamp):
                            results_list.append(result_info)
                    
                    # 按时间降序排序
                    results_list.sort(key=lambda x: x.get("raw_timestamp", datetime.min), reverse=True)
                    
                    print(f"[TianAPI] 最终获取到{len(results_list)}条有效新闻")
                    return results_list
                else:
                    error_msg = data.get('msg', '未知错误')
                    print(f"[TianAPI] 返回错误: {error_msg} (错误码: {data.get('code')})")
                    # 如果是关键词相关的错误，尝试使用更简单的关键词
                    if "数据返回为空" in error_msg or data.get('code') == 250:
                        # 提取核心关键词列表
                        core_keywords = self._extract_core_keywords(simplified_query)
                        print(f"[TianAPI] 尝试使用核心关键词列表: {core_keywords}")
                        
                        # 尝试列表中的每个关键词
                        for simple_keyword in core_keywords:
                            # 跳过空关键词或太短的关键词
                            if not simple_keyword or len(simple_keyword) < 2:
                                continue
                                
                            print(f"[TianAPI] 尝试使用关键词: '{simple_keyword}'")
                            simple_params = params.copy()
                            simple_params['word'] = simple_keyword
                            
                            try:
                                simple_response = requests.get(url, params=simple_params, timeout=self.tianapi_timeout)
                                if simple_response.status_code == 200:
                                    simple_data = simple_response.json()
                                    if simple_data.get("code") == 200:
                                        simple_news_items = simple_data.get("result", {}).get("newslist", [])
                                        if simple_news_items:
                                            print(f"[TianAPI] 使用简化关键词 '{simple_keyword}' 成功获取{len(simple_news_items)}条新闻")
                                            # 处理简化关键词获取的结果
                                            results_list = []
                                            for news_item in simple_news_items:
                                                result_date = news_item.get("time", news_item.get("ctime", ""))
                                                try:
                                                    parsed_timestamp = datetime.strptime(result_date, "%Y-%m-%d %H:%M:%S")
                                                except:
                                                    parsed_timestamp = datetime.now()
                                                
                                                result_info = {
                                                    "title": news_item.get("title", ""),
                                                    "snippet": news_item.get("description", ""),
                                                    "url": news_item.get("url", ""),
                                                    "source": news_item.get("source", ""),
                                                    "date": result_date,
                                                    "timestamp": parsed_timestamp.isoformat(),
                                                    "raw_timestamp": parsed_timestamp
                                                }
                                                
                                                if self._is_valid_time_info(result_date, parsed_timestamp):
                                                    results_list.append(result_info)
                                            
                                            results_list.sort(key=lambda x: x.get("raw_timestamp", datetime.min), reverse=True)
                                            return results_list
                            except Exception as e:
                                print(f"[TianAPI] 使用简化关键词 '{simple_keyword}' 时出错: {str(e)}")
                                continue
                    return None
            else:
                print(f"[TianAPI] 请求失败，状态码: {response.status_code}")
                print(f"[TianAPI] 响应内容: {response.text}")
                return None
        
        except Exception as e:
            print(f"[TianAPI] 调用异常: {str(e)}")
            return None
    
    def _simplify_query(self, query: str) -> str:
        """简化搜索查询，移除复杂修饰词，保留核心关键词"""
        # 移除常见的时间修饰词和复杂描述
        time_terms = ["最近一周", "最新", "近期", "最近动态", "当前事件", 
                     "刚刚发生", "本周", "最新进展", "近期更新", "一周内", 
                     "快讯", "热搜", "最近情况", "刚刚", "突发", "近期动态"]
        
        # 移除平台名称
        platform_terms = ["微博", "头条", "抖音"]
        
        # 移除日期格式（例如：2025-10-23）
        import re
        query = re.sub(r'\d{4}-\d{2}-\d{2}', '', query)
        query = re.sub(r'\d{2}:\d{2}', '', query)
        
        # 移除时间修饰词
        simplified = query
        for term in time_terms + platform_terms:
            simplified = simplified.replace(term, '')
        
        # 移除多余的空格
        simplified = ' '.join(simplified.split())
        
        # 如果结果太短或为空，返回原始查询
        if len(simplified) < 2 and query.strip():
            return query.strip()
        
        return simplified.strip()
    
    def _extract_core_keywords(self, query: str) -> list:
        """提取查询中的核心关键词，用于在初始查询失败时尝试"""
        # 如果有空格，返回按空格分割的词列表
        if ' ' in query:
            return query.split()
        
        # 如果没有空格，尝试按长度分割
        # 对于中文查询，我们可以按一定长度截取前几个字符
        core_keywords = []
        
        # 添加原始查询
        core_keywords.append(query)
        
        # 添加前2个字符
        if len(query) >= 2:
            core_keywords.append(query[:2])
        
        # 添加前3个字符
        if len(query) >= 3:
            core_keywords.append(query[:3])
        
        # 添加前4个字符
        if len(query) >= 4:
            core_keywords.append(query[:4])
        
        return core_keywords
    
    def search_news_info(self, query: str) -> Optional[List[Dict[str, str]]]:
        """搜索最新新闻信息，优先使用天聚数行（TianAPI）"""
        # 优先使用天聚数行API
        tianapi_results = self.search_news_info_tianapi(query)
        if tianapi_results and len(tianapi_results) > 0:
            print(f"成功从TinaAPI获取到{len(tianapi_results)}条新闻结果")
            return tianapi_results
        
        # 如果TianAPI失败，尝试使用博查AI API作为备用
        print("天聚数行API未返回有效结果，尝试使用博查AI API")
        
        if not self.web_search_api_key:
            print("博查AI搜索API密钥未配置，跳过搜索")
            return None
        
        try:
            headers = {
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.web_search_api_key}"
            }
            
            # 获取当前日期和时间
            now = datetime.now()
            current_date = now.strftime("%Y-%m-%d")
            
            # 构建时效性查询，关注最近一周内的信息，避免包含可能导致错误时间信息的关键词
            enhanced_query = f"{query} 最近一周 最新 近期 最近动态 当前事件"
            
            # 计算一周前的日期
            one_week_ago = now - timedelta(days=7)
            one_week_ago_str = one_week_ago.strftime("%Y-%m-%d")
            
            payload = {
                "query": enhanced_query,
                "num_results": self.search_num_results,  # 从配置获取结果数量
                "search_type": "news",  # 指定搜索类型为新闻
                "sort_by": "time",  # 按时间排序，优先返回最新内容
                "time_range": "week",  # 扩展时间范围到最近一周
                "freshness": "high",  # 高新鲜度优先
                "start_date": one_week_ago_str,  # 明确指定开始日期
                "end_date": current_date  # 明确指定结束日期
            }
            
            response = requests.post(self.web_search_api_url, headers=headers, json=payload, timeout=self.search_timeout)
            
            if response.status_code == 200:
                search_results = response.json()
                # 提取有用的信息
                results_list = []
                current_year = str(datetime.now().year)
                for result in search_results.get("results", []):
                    # 提取并格式化时间信息，便于排序
                    result_date = result.get("date", "")
                    result_timestamp = result.get("timestamp", "")
                    
                    # 验证内容中是否包含不合理的年份信息
                    snippet = result.get("snippet", "")
                    if any(invalid in snippet for invalid in ["2025年", "2026年", "特朗普 前总统"]):
                        print(f"跳过包含不合理时间信息的结果: {result.get('title', '')}")
                        continue
                    
                    # 尝试解析时间戳，如果没有则使用当前时间
                    parsed_timestamp = None
                    if result_timestamp:
                        try:
                            parsed_timestamp = datetime.fromisoformat(result_timestamp)
                        except:
                            parsed_timestamp = datetime.now()
                    elif result_date:
                        try:
                            # 尝试多种日期格式解析
                            for fmt in ['%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M', '%Y-%m-%d', '%m-%d %H:%M']:
                                try:
                                    parsed_timestamp = datetime.strptime(result_date, fmt)
                                    break
                                except ValueError:
                                    continue
                        except:
                            parsed_timestamp = datetime.now()
                    else:
                        parsed_timestamp = datetime.now()
                    
                    result_info = {
                        "title": result.get("title", ""),
                        "snippet": snippet,
                        "url": result.get("url", ""),
                        "source": result.get("source", ""),
                        "date": result_date,
                        "timestamp": parsed_timestamp.isoformat(),
                        "raw_timestamp": parsed_timestamp  # 保存解析后的datetime对象，用于精确排序
                    }
                    
                    # 验证时间信息的合理性
                    if self._is_valid_time_info(result_date, parsed_timestamp):
                        results_list.append(result_info)
                    else:
                        print(f"跳过时间信息不合理的结果: {result.get('title', '')}, 时间: {result_date}")
                
                # 优先按解析后的datetime对象排序，确保最精确的时间排序
                results_list.sort(key=lambda x: x.get("raw_timestamp", datetime.min), reverse=True)
                
                return results_list
            else:
                print(f"搜索API返回错误状态码: {response.status_code}")
                print(f"错误信息: {response.text}")
                return None
        
        except Exception as e:
            print(f"搜索API调用失败: {e}")
            return None
    
    def _generate_single_summary(self, item: Dict, platform: str) -> str:
        """为单个事件生成总结，使用Web搜索获取最新真实信息"""
        title = item.get('title', '未知标题')
        hot = item.get('hot', '未知热度')
        index = item.get('index', '未知排名')
        url = item.get('url', '')
        
        # 获取当前日期和时间
        current_date = datetime.now().strftime("%Y-%m-%d")
        current_time = datetime.now().strftime("%H:%M")
        
        # 定义搜索策略，优化为更简洁的查询，便于TianAPI处理
        # 减少复杂修饰词，优先使用简单关键词组合
        search_strategies = [
            # 最简单的查询，只有标题和平台
            f"{title} {platform}",
            # 稍微复杂一点，但仍然简洁
            f"{title} {platform} 最新",
            # 包含一些时效性但不过于复杂
            f"{title} 最新 热点",
            # 进一步简化
            f"{title} 热点",
            # 只保留核心标题
            f"{title}"
        ]
        
        search_results = None
        
        # 尝试每种搜索策略，直到获取到结果
        for i, search_query in enumerate(search_strategies):
            print(f"[{current_date} {current_time}] 搜索策略 {i+1}/{len(search_strategies)}: {search_query}")
            search_results = self.search_news_info(search_query)
            
            # 检查是否获取到有效的今日结果
            if search_results and len(search_results) > 0:
                # 过滤保留最近一周内的结果
                recent_results = []
                now = datetime.now()
                for result in search_results:
                    # 首先验证时间信息的合理性
                    result_date = result.get("date", "")
                    result_timestamp = result.get("raw_timestamp", datetime.min)
                    
                    # 跳过时间信息不合理的结果
                    if not self._is_valid_time_info(result_date, result_timestamp):
                        print(f"跳过时间信息不合理的结果: {result.get('title', '')}, 时间: {result_date}")
                        continue
                    
                    # 检查是否为最近一周内的结果
                    is_recent = False
                    if result_timestamp and result_timestamp != datetime.min:
                        # 检查时间戳是否在一周内
                        if (now - result_timestamp).days <= 7:
                            is_recent = True
                    elif result_date:
                        # 检查日期字符串是否包含近期标识
                        if any(keyword in result_date for keyword in ["今天", "昨日", "近日", "最近", "刚刚"]):
                            is_recent = True
                        # 也检查是否包含当前年份的日期格式
                        elif current_date[:4] in result_date:  # 检查是否包含当前年份
                            # 尝试解析日期
                            try:
                                parsed_date = None
                                date_part = result_date.split(' ')[0]
                                for fmt in ['%Y-%m-%d', '%Y/%m/%d', '%Y年%m月%d日', '%Y-%m-%d %H:%M', '%Y-%m-%d %H:%M:%S']:
                                    try:
                                        parsed_date = datetime.strptime(date_part, fmt)
                                        break
                                    except:
                                        continue
                                if parsed_date and (now - parsed_date).days <= 7:
                                    is_recent = True
                            except:
                                # 如果解析失败，尝试检查是否包含近期描述
                                if any(keyword in result_date for keyword in ["本周", "最近", "近期", "近几天"]):
                                    is_recent = True
                    
                    # 添加有效的近期结果
                    if is_recent:
                        recent_results.append(result)
                
                if recent_results:
                    print(f"找到{len(recent_results)}条最近一周内的相关信息")
                    # 按时间戳排序，最新的排在前面
                    recent_results.sort(key=lambda x: x.get("raw_timestamp", datetime.min), reverse=True)
                    search_results = recent_results[:self.search_num_results]  # 限制返回结果数量
                    break
        
        # 如果所有策略都失败，使用最后的备用方案
        if not search_results or len(search_results) == 0:
            print(f"未找到最近一周内的相关信息，使用备用查询...")
            # 备用查询也简化，只保留核心标题
            emergency_query = f"{title}"
            search_results = self.search_news_info(emergency_query)
        
        # 2. 构建包含真实信息的提示词
        prompt = self._build_summary_prompt(title, hot, index, platform, search_results)
        
        if not self.llm_client:
            return self._generate_fallback_summary(title, platform)
            
        try:
            # 3. 使用DeepSeek API生成基于真实信息的摘要
            response = self.llm_client.invoke([prompt])
            content = response.content.strip()
            
            # 清理可能的markdown格式
            if content.startswith('```'):
                lines = content.split('\n')
                content = '\n'.join(lines[1:-1]).strip() if len(lines) > 2 else content.replace('```', '').strip()
                
            return content
        except Exception as e:
            print(f"大模型生成总结失败: {e}")
            return self._generate_fallback_summary(title, platform, search_results)

    def _build_summary_prompt(self, title: str, hot: Any, index: Any, platform: str, search_results: Optional[List[Dict[str, str]]] = None) -> SystemMessage:
        """构建基于最新真实搜索结果的总结生成提示词"""
        # 获取当前日期
        current_date = datetime.now().strftime("%Y-%m-%d")
        
        # 构建搜索结果文本，特别强调最新的信息
        search_results_text = ""
        if search_results and len(search_results) > 0:
            search_results_text = f"\n\n以下是从权威新闻来源获取的{current_date}最新相关信息（按时间从新到旧排序）：\n"
            for i, result in enumerate(search_results, 1):
                date_info = result.get('date', '') or result.get('timestamp', '')
                search_results_text += f"{i}. 标题: {result.get('title', '无标题')}\n"
                search_results_text += f"   摘要: {result.get('snippet', '无摘要')}\n"
                search_results_text += f"   来源: {result.get('source', '未知')} {date_info}\n\n"
                
                # 限制只显示最新的3条信息，避免信息过载
                if i >= 3:
                    break
        else:
            search_results_text = f"\n\n注意：未能获取到{current_date}最近一周内相关的新闻搜索结果。请仅基于标题进行合理推测。"
        
        prompt_text = f"""
        你是一个专业的新闻编辑和事件分析专家。请基于最近一周内的最新新闻信息，为以下{platform}热搜事件生成一个准确、客观的事件总结。

        事件信息：
        - 标题：{title}
        - 热度：{hot}
        - 排名：{index}
        - 平台：{platform}
        - 当前日期：{current_date}
        {search_results_text}

        请根据以上信息生成150-250字的客观事件总结，严格遵循以下要求：
        1. **优先最新信息**：优先使用今日（{current_date}）发布的最新新闻信息，特别关注时间戳较新的内容
        2. **基于事实**：完全基于搜索结果中的真实新闻信息，避免任何凭空猜测
        3. **信息时效性**：明确指出事件发生的时间（如果有），强调"今日"、"最新"等时效性词汇
        4. **信息来源**：明确引用搜索结果中的新闻来源，增强总结的可信度
        5. **客观中立**：保持完全客观的态度，只陈述事实，避免任何主观评价
        6. **结构清晰**：先介绍事件的最新进展，再简要分析背景和当前影响
        7. **语言精准**：使用准确、具体的词汇描述事件，避免模糊和笼统的表述
        8. **平台适配**：根据平台特性适当调整风格（微博偏向社会热点，头条偏向新闻资讯，抖音偏向娱乐内容）

        请直接输出总结内容，不要包含任何额外的说明或格式标记。
        """
        
        return SystemMessage(content=prompt_text)

    def _generate_fallback_summary(self, title: str, platform: str, search_results: Optional[List[Dict[str, str]]] = None) -> str:
        """生成回退总结（当大模型不可用时）"""
        if search_results and len(search_results) > 0:
            # 如果有搜索结果，基于搜索结果生成简单总结
            sources = [result.get('source', '未知来源') for result in search_results if result.get('source')]
            unique_sources = list(set(sources))[:2]  # 获取最多2个唯一来源
            source_text = "、".join(unique_sources)
            return f"这是{platform}平台关于'{title}'的热点事件。根据{source_text}等媒体报道，该事件引发广泛关注。由于技术原因，无法生成详细分析，请通过官方媒体获取完整信息。"
        else:
            # 没有搜索结果时的默认总结
            return f"这是一个在{platform}平台关于'{title}'的热点事件。未能获取到相关新闻信息，建议关注官方媒体和权威渠道获取准确的事件详情。"
